home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / hplip / base / maint.py < prev    next >
Encoding:
Python Source  |  2009-04-14  |  42.6 KB  |  1,449 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2003-2007 Hewlett-Packard Development Company, L.P.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18. #
  19. # Author: Don Welch
  20. #
  21.  
  22. # NOTE: Not used by Qt4 code. Use maint_*.py modules instead.
  23.  
  24. # Local
  25. from g import *
  26. from codes import *
  27. import status, pml
  28. from prnt import pcl, ldl, colorcal
  29.  
  30. # ********************** Align **********************
  31.  
  32. def AlignType1(dev, loadpaper_ui): # Auto VIP (using embedded PML)
  33.     ok = loadpaper_ui()
  34.     if ok:
  35.         dev.writeEmbeddedPML(pml.OID_AUTO_ALIGNMENT,
  36.                              pml.AUTO_ALIGNMENT, style=0, 
  37.                              direct=True)
  38.         dev.closePrint()
  39.  
  40.     return ok
  41.     
  42. def AlignType1PML(dev, loadpaper_ui): # Auto VIP (using PML)
  43.     ok = loadpaper_ui()
  44.     if ok:
  45.         dev.setPML(pml.OID_AUTO_ALIGNMENT, pml.AUTO_ALIGNMENT)
  46.         dev.closePML()
  47.  
  48.     return ok
  49.  
  50.  
  51.  
  52. def AlignType2(dev, loadpaper_ui, align_ui, bothpens_ui): # 8xx
  53.     state, a, b, c, d = 0, 6, 6, 3, 3
  54.     ok = False
  55.     while state != -1:
  56.         if state == 0:
  57.             state = 1
  58.             pens = dev.getStatusFromDeviceID()['agents']
  59.             pen_types = [pens[x] for x in range(len(pens))]
  60.             if AGENT_TYPE_NONE in pen_types:
  61.                 log.error("Cannot perform alignment with 0 or 1 pen installed.")
  62.                 state = 100
  63.  
  64.         elif state == 1:
  65.             state = -1
  66.             ok = loadpaper_ui()
  67.             if ok:
  68.                 state = 2
  69.  
  70.         elif state == 2:
  71.             state = -1
  72.             alignType2Phase1(dev)
  73.             ok, a = align_ui('A', 'h', 'kc', 2, 11)
  74.             if ok:
  75.                 state = 3
  76.  
  77.         elif state == 3:
  78.             state = -1
  79.             ok, b = align_ui('B', 'v', 'kc', 2, 11)
  80.             if ok:
  81.                 state = 4
  82.  
  83.         elif state == 4:
  84.             state = -1
  85.             ok, c = align_ui('C', 'v', 'kc', 2, 5)
  86.             if ok:
  87.                 state = 5
  88.  
  89.         elif state == 5:
  90.             state = -1
  91.             ok, d = align_ui('D', 'v', 'c', 2, 5)
  92.             if ok:
  93.                 state = 6
  94.  
  95.         elif state == 6:
  96.             ok = loadpaper_ui()
  97.             if ok:
  98.                 alignType2Phase2(dev, a, b, c, d)
  99.             state = -1
  100.  
  101.         elif state == 100:
  102.             ok = False
  103.             bothpens_ui()
  104.             state = -1
  105.  
  106.     return ok
  107.  
  108.  
  109.  
  110. def AlignType3(dev, loadpaper_ui, align_ui, paperedge_ui, align_type): # 9xx
  111.     state, a, b, c, d, zca = 0, 6, 6, 3, 3, 6
  112.     ok = False
  113.     while state != -1:
  114.         if state == 0:
  115.             state = -1
  116.             ok = loadpaper_ui()
  117.             if ok:
  118.                 alignType3Phase1(dev)
  119.                 state = 1
  120.  
  121.         elif state == 1:
  122.             state = -1
  123.             ok, a = align_ui('A', 'h', 'kc', 2, 11)
  124.             if ok:
  125.                 state = 2
  126.  
  127.         elif state == 2:
  128.             state = -1
  129.             ok, b = align_ui('B', 'v', 'kc', 2, 11)
  130.             if ok:
  131.                 state = 3
  132.  
  133.         elif state == 3:
  134.             state = -1
  135.             ok, c = align_ui('C', 'v', 'k', 2, 11)
  136.             if ok:
  137.                 state = 4
  138.  
  139.         elif state == 4:
  140.             state = -1
  141.             ok, d = align_ui('D', 'v', 'kc', 2, 11)
  142.             if ok:
  143.                 state = 5
  144.  
  145.         elif state == 5:
  146.             state = -1
  147.             alignType3Phase2(dev, a, b, c, d)
  148.             if align_type == 9:
  149.                 state = 7
  150.             else:
  151.                 ok = loadpaper_ui()
  152.                 if ok:
  153.                     state = 6
  154.  
  155.         elif state == 6:
  156.             state = -1
  157.             alignType3Phase3(dev)
  158.             ok, zca = paperedge_ui(13)
  159.             if ok:
  160.                 state = 7
  161.  
  162.         elif state == 7:
  163.             ok = loadpaper_ui()
  164.             if ok:
  165.                 alignType3Phase4(dev, zca)
  166.             state = -1
  167.  
  168.     return ok
  169.  
  170.  
  171. def AlignxBow(dev, align_type, loadpaper_ui, align_ui, paperedge_ui,
  172.                invalidpen_ui, coloradj_ui): # Types 4, 5, and 7
  173.  
  174.     state, statepos = 0, 0
  175.     user_cancel_states = [1000, -1]
  176.     a, b, c, d, e, f, g = 0, 0, 0, 0, 0, 0, 0
  177.     error_states = [-1]
  178.     ok = False
  179.  
  180.     dev.pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  181.  
  182.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  183.         state, states = 100, [-1]
  184.  
  185.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  186.         state, states = 0, [2, 200, 3, -1]
  187.  
  188.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  189.         state, states = 0, [2, 200, 3, -1]
  190.  
  191.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  192.         state, states = 0, [2, 300, 3, -1]
  193.  
  194.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  195.         state, states = 0, [2, 400, 500, 600, 700, 3, 4, -1]
  196.  
  197.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  198.         state, states = 0, [2, 400, 500, 600, 700, 800, 900, 3, 4, -1]
  199.  
  200.     while state != -1:
  201.  
  202.         if state == 0:
  203.             ok = loadpaper_ui()
  204.             if ok:
  205.                 if align_type == 4:
  206.                     alignType4Phase1(dev)
  207.                 elif align_type == 5:
  208.                     alignType5Phase1(dev)
  209.                 elif align_type == 7:
  210.                     alignType7Phase1(dev)
  211.                 else:
  212.                     statepos, states = 0, error_states
  213.             else:
  214.                 statepos, states = 0, user_cancel_states
  215.  
  216.  
  217.         elif state == 2:
  218.             ok, a = paperedge_ui(13)
  219.             if not ok:
  220.                 statepos, states = 0, user_cancel_states
  221.  
  222.         elif state == 3:
  223.             if align_type == 4:
  224.                 alignType4Phase2(dev, a, b, c, d, e)
  225.             elif align_type == 5:
  226.                 alignType5Phase2(dev, a, b, c, d, e, f, g)
  227.             else:
  228.                 alignType7Phase2(dev, a, b, c, d, e, f, g)
  229.  
  230.         elif state == 4:
  231.             ok = loadpaper_ui()
  232.             if ok:
  233.                 if align_type == 4:
  234.                     alignType4Phase3(dev)
  235.                 elif align_type == 5:
  236.                     alignType5Phase3(dev)
  237.                 else:
  238.                     alignType7Phase3(dev)
  239.             else:
  240.                 statepos, states = 0, user_cancel_states
  241.  
  242.         elif state == 100:
  243.             invalidpen_ui()
  244.             state = -1
  245.  
  246.         elif state == 200: # B Line - Black only or photo only
  247.             ok, b = align_ui('B', 'v', 'k', 2, 11)
  248.             if not ok:
  249.                 statepos, states = 0, user_cancel_states
  250.  
  251.         elif state == 300: # B Line - Color only
  252.             ok, b = align_ui('B', 'v', 'kc', 2, 11)
  253.             if not ok:
  254.                 statepos, states = 0, user_cancel_states
  255.  
  256.         elif state == 400: # B Line - 2 pen
  257.             ok, b = align_ui('B', 'h', 'kc', 2, 17)
  258.             if not ok:
  259.                 statepos, states = 0, user_cancel_states
  260.  
  261.         elif state == 500: # C Line
  262.             ok, c = align_ui('C', 'v', 'kc', 2, 17)
  263.             if not ok:
  264.                 statepos, states = 0, user_cancel_states
  265.  
  266.         elif state == 600 : # D Line
  267.             ok, d = align_ui('D', 'v', 'k', 2, 11)
  268.             if not ok:
  269.                 statepos, states = 0, user_cancel_states
  270.  
  271.         elif state == 700: # E Line
  272.             ok, e = align_ui('E', 'v', 'kc', 2, 11)
  273.             if not ok:
  274.                 statepos, states = 0, user_cancel_states
  275.  
  276.         elif state == 800: # F Line
  277.             ok, f = coloradj_ui('F', 21)
  278.             if not ok:
  279.                 statepos, states = 0, user_cancel_states
  280.  
  281.         elif state == 900: # G Line
  282.             ok, f = coloradj_ui('G', 21)
  283.             if not ok:
  284.                 statepos, states = 0, user_cancel_states
  285.  
  286.         elif state == 1000: # User cancel
  287.             ok = False
  288.             log.warning("Alignment canceled at user request.")
  289.  
  290.         state = states[statepos]
  291.         statepos += 1
  292.  
  293.     return ok
  294.  
  295.  
  296. def AlignType6(dev, ui1, ui2, loadpaper_ui):
  297.     state = 0
  298.     ok = False
  299.  
  300.     while state != -1:
  301.         if state == 0:
  302.             state = 2
  303.             accept = ui1()
  304.             if not accept:
  305.                 # Need to printout alignment page
  306.                 state = 1
  307.  
  308.         elif state == 1: # Load and print
  309.             state = -1
  310.             ok = loadpaper_ui()
  311.             if ok:
  312.                 alignType6Phase1(dev)
  313.                 state = 2
  314.  
  315.         elif state == 2: # Finish
  316.             ui2()
  317.             state = -1
  318.  
  319.  
  320.     return ok
  321.  
  322. def AlignType8(dev, loadpaper_ui, align_ui): # 450
  323.     state, a, b, c, d = 0, 5, 5, 5, 5
  324.     ok = False
  325.  
  326.     while state != -1:
  327.  
  328.         if state == 0:
  329.             state = -1
  330.             ok = loadpaper_ui()
  331.             if ok:
  332.                 num_inks = alignType8Phase1(dev)
  333.                 state = 1
  334.  
  335.         elif state == 1:
  336.             state = -1
  337.             ok, a = align_ui('A', 'v', 'k', 3, 9)
  338.             if ok:
  339.                 state = 2
  340.  
  341.         elif state == 2:
  342.             state = -1
  343.             ok, b = align_ui('B', 'v', 'c', 3, 9)
  344.             if ok:
  345.                 state = 3
  346.  
  347.         elif state == 3:
  348.             state = -1
  349.             ok, c = align_ui('C', 'v', 'kc', 3, 9)
  350.             if ok:
  351.                 state = 4
  352.  
  353.         elif state == 4:
  354.             state = -1
  355.             ok, d = align_ui('D', 'h', 'kc', 3, 9)
  356.             if ok:
  357.                 state = 5
  358.  
  359.         elif state == 5:
  360.             alignType8Phase2(dev, num_inks, a, b, c, d)
  361.             state = -1
  362.  
  363.     return ok
  364.  
  365.  
  366. def AlignType10(dev, loadpaper_ui, align_ui):
  367.     pattern = alignType10SetPattern(dev)
  368.     state = 0
  369.  
  370.     while state != -1:
  371.         if state == 0:
  372.             state = -1
  373.             ok = loadpaper_ui()
  374.             if ok:
  375.                 alignType10Phase1(dev)
  376.                 state = 1
  377.  
  378.         elif state == 1:
  379.             values = align_ui(pattern, ALIGN_TYPE_LBOW)
  380.             log.debug(values)
  381.             alignType10Phase2(dev, values, pattern)
  382.             state = 2
  383.  
  384.         elif state == 2:
  385.             state = -1
  386.             ok = loadpaper_ui()
  387.             if ok:
  388.                 alignType10Phase3(dev)
  389.  
  390.  
  391. def alignType10SetPattern(dev):
  392.     pattern = None
  393.     pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  394.     log.debug("Pen config=%d" % pen_config)
  395.  
  396.     if pen_config == AGENT_CONFIG_BLACK_ONLY:
  397.         pattern = 1
  398.  
  399.     elif pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  400.         pattern = 2
  401.  
  402.     elif pen_config in (AGENT_CONFIG_COLOR_AND_PHOTO, AGENT_CONFIG_COLOR_AND_GREY):
  403.         pattern = 3
  404.  
  405.     log.debug("Pattern=%d" % pattern)
  406.     return pattern
  407.     
  408.  
  409. def alignType10Phase1(dev):
  410.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  411.                          pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE)
  412.  
  413.     dev.closePrint()
  414.  
  415.  
  416. def alignType10Phase2(dev, values, pattern):
  417.     i, p = 0, ''.join([pcl.UEL, '\n'])
  418.  
  419.     for x in values:
  420.         i += 1
  421.         if not x:
  422.             break
  423.         p = ''.join([p, pcl.ESC, '*o5W\x1a', chr(i), '\x00', chr(pattern), chr(x), '\n'])
  424.  
  425.     p = ''.join([p, pcl.UEL]) 
  426.  
  427.     dev.printData(p)
  428.     dev.closePrint()
  429.  
  430.  
  431. def alignType10Phase3(dev):
  432.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  433.                          pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE_VERIFICATION)
  434.  
  435.     dev.closePrint()
  436.  
  437.  
  438. def align10and11Controls(pattern, align_type):
  439.     if align_type == ALIGN_TYPE_LIDIL_0_5_4:
  440.         if pattern == 1:
  441.             controls = { 'A' : (True, 23),
  442.                          'B' : (True, 9),
  443.                          'C' : (True, 9),
  444.                          'D' : (False, 0),
  445.                          'E' : (False, 0),
  446.                          'F' : (False, 0),
  447.                          'G' : (False, 0),
  448.                          'H' : (False, 0),}
  449.         elif pattern == 2: # K + color (ii)
  450.             controls = { 'A' : (True, 17),
  451.                          'B' : (True, 23),
  452.                          'C' : (True, 23),
  453.                          'D' : (True, 23),
  454.                          'E' : (True, 9),
  455.                          'F' : (True, 9),
  456.                          'G' : (True, 9),
  457.                          'H' : (True, 9),}
  458.  
  459.         elif pattern == 3: # color + photo (iii)
  460.             controls = { 'A' : (True, 9),
  461.                          'B' : (True, 23),
  462.                          'C' : (True, 23),
  463.                          'D' : (True, 23),
  464.                          'E' : (True, 9),
  465.                          'F' : (True, 9),
  466.                          'G' : (True, 9),
  467.                          'H' : (True, 9),}    
  468.  
  469.     else:
  470.         if pattern == 1:
  471.             controls = {'A' : (True, 23),
  472.                          'B' : (True, 9),
  473.                          'C' : (True, 9),
  474.                          'D' : (False, 0),
  475.                          'E' : (False, 0),
  476.                          'F' : (False, 0),
  477.                          'G' : (False, 0),
  478.                          'H' : (False, 0),}
  479.         elif pattern == 2:
  480.             controls = {'A' : (True, 23),
  481.                         'B' : (True, 17),
  482.                          'C' : (True, 23),
  483.                          'D' : (True, 23),
  484.                          'E' : (True, 9),
  485.                          'F' : (True, 9),
  486.                          'G' : (True, 9),
  487.                          'H' : (True, 9),}
  488.  
  489.         elif pattern == 3:
  490.             controls = {'A' : (True, 23),
  491.                          'B' : (True, 9),
  492.                          'C' : (True, 23),
  493.                          'D' : (True, 23),
  494.                          'E' : (True, 9),
  495.                          'F' : (True, 9),
  496.                          'G' : (True, 9),
  497.                          'H' : (True, 9),}
  498.  
  499.     return controls
  500.  
  501.  
  502. def AlignType11(dev, loadpaper_ui, align_ui, invalidpen_ui):
  503.     pattern = alignType11SetPattern(dev)
  504.     if pattern is None:
  505.         invalidpen_ui()
  506.         return
  507.         
  508.     state = 0
  509.     while state != -1:
  510.         if state == 0:
  511.             state = -1
  512.             ok = loadpaper_ui()
  513.             if ok:
  514.                 alignType11Phase1(dev)
  515.                 state = 1
  516.  
  517.         elif state == 1:
  518.             values = align_ui(pattern, ALIGN_TYPE_LIDIL_0_5_4)
  519.             log.debug(values)
  520.             alignType11Phase2(dev, values, pattern, dev.pen_config)
  521.             state = 2
  522.  
  523.         elif state == 2:
  524.             state = -1
  525.             ok = loadpaper_ui()
  526.             if ok:
  527.                 alignType11Phase3(dev)
  528.  
  529.  
  530. def alignType11SetPattern(dev):
  531.     pattern = None
  532.     dev.pen_config = status.getPenConfiguration(dev.getStatusFromDeviceID())
  533.     log.debug("Pen config=%d" % dev.pen_config)
  534.  
  535.     if dev.pen_config in (AGENT_CONFIG_BLACK_ONLY, AGENT_CONFIG_COLOR_ONLY): # (i)
  536.         pattern = 1
  537.  
  538.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK: # (ii)
  539.         pattern = 2
  540.  
  541.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO: # (iii)
  542.         pattern = 3
  543.  
  544.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  545.         return None
  546.  
  547.     log.debug("Pattern=%d" % pattern) 
  548.     return pattern
  549.     
  550.  
  551. def alignType11Phase1(dev):
  552.     dev.printData(ldl.buildResetPacket())
  553.     dev.printData(ldl.buildReportPagePacket(ldl.COMMAND_REPORT_PAGE_PEN_CALIBRATION))
  554.     dev.closePrint()
  555.  
  556.  
  557. def alignType11Phase2(dev, values, pattern, pen_config):
  558.     active_colors = 0
  559.  
  560.     if pen_config == AGENT_CONFIG_BLACK_ONLY:
  561.         active_colors = ldl.COMMAND_SET_PEN_ALIGNMENT_3_K
  562.         values = values[:3]
  563.  
  564.     elif pen_config == AGENT_CONFIG_COLOR_ONLY:
  565.         active_colors = COMMAND_SET_PEN_ALIGNMENT_3_COLOR
  566.         values = values[:3]
  567.  
  568.     elif pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  569.         active_colors = ldl.COMMAND_SET_PEN_ALIGNMENT_3_K | ldl.COMMAND_SET_PEN_ALIGNMENT_3_COLOR
  570.  
  571.     elif pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  572.         active_colors = ldl.COMMAND_SET_PEN_ALIGNMENT_3_COLOR | ldl.COMMAND_SET_PEN_ALIGNMENT_3_PHOTO
  573.  
  574.     log.debug("Active colors=0x%x Values=%s" % (active_colors, values))
  575.  
  576.     dev.printData(ldl.buildSetPenAlignment3Packet(active_colors, values))
  577.     dev.closePrint()
  578.  
  579.  
  580. def AlignType13(dev, loadpaper_ui, scanner_align_load_ui): # Auto AiO (Yellowtail)
  581.     ok = loadpaper_ui()
  582.     if ok:
  583.         alignType13Phase1(dev)
  584.         ok = scanner_align_load_ui()
  585.  
  586.     return ok
  587.  
  588. def alignType13Phase1(dev):
  589.     dev.setPML(pml.OID_AUTO_ALIGNMENT, pml.AUTO_ALIGNMENT)
  590.     dev.closePML()
  591.  
  592. def alignType11Phase3(dev):
  593.     dev.printData(ldl.buildResetPacket())
  594.     dev.printData(ldl.buildReportPagePacket(ldl.COMMAND_REPORT_PAGE_PEN_CALIBRATION_VERIFY))
  595.     dev.closePrint()
  596.  
  597. def alignType2Phase1(dev): # Type 2 (8xx)
  598.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  599.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  600.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  601.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  602.     dev.closePrint()
  603.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align1_8xx.pcl.gz'))
  604.  
  605.  
  606. def alignType2Phase2(dev, a, b, c, d): # (8xx)
  607.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, (a - 6) * 12)
  608.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, (b - 6) * 12)
  609.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, (c - 3) * 12)
  610.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, (d - 3) * 12)
  611.     dev.writeEmbeddedPML(pml.OID_MARKING_AGENTS_INITIALIZED, 3)
  612.     dev.closePrint()
  613.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align2_8xx.pcl.gz'))
  614.  
  615.  
  616. def alignType3Phase1(dev): # Type 3 (9xx)
  617.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  618.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  619.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  620.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  621.     dev.closePrint()
  622.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align1_9xx.pcl.gz'))
  623.  
  624.  
  625. def alignType3Phase2(dev, a, b, c, d): # Type 3 (9xx)
  626.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, (a - 6) * 12)
  627.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, (6 - b) * 12)
  628.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, (6 - c) * 12)
  629.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, (6 - d) * 6)
  630.     dev.closePrint()
  631.  
  632. def alignType3Phase3(dev): # Type 3 (9xx)
  633.     dev.closePrint()
  634.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align3_9xx.pcl.gz'))
  635.  
  636.  
  637. def alignType3Phase4(dev, zca): # Type 3 (9xx)
  638.     dev.writeEmbeddedPML(pml.OID_MARKING_AGENTS_INITIALIZED, 3)
  639.     dev.closePrint()
  640.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'align2_9xx.pcl.gz'))
  641.  
  642.  
  643. def alignType4Phase1(dev): # Type 4 (xBow/LIDIL 0.3.8)
  644.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_RESUME_NORMAL_OPERATION))
  645.  
  646.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  647.         return
  648.  
  649.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  650.         ldl_file = 'cbbcal.ldl.gz'
  651.  
  652.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  653.         ldl_file = 'cbccal.ldl.gz'
  654.  
  655.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  656.         ldl_file = 'cb2pcal.ldl.gz'
  657.  
  658.     dev.printData(ldl.buildSetPrinterAlignmentPacket(0, 0, 0, 0))
  659.     dev.closePrint()
  660.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', ldl_file))
  661.  
  662.  
  663. def alignType4Phase2(dev, a, b, c, d, e): # Type 4 (LIDIL 0.3.8)
  664.     log.debug("A=%d, B=%d, C=%d, D=%d, E=%d" % (a, b, c, d, e))
  665.  
  666.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  667.         return
  668.  
  669.     # ZCA
  670.     zca = (7 - a) * -48
  671.     dev.printData(ldl.buildZCAPacket(zca))
  672.  
  673.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  674.         k_bidi = (6 - b) * 2
  675.         dev.printData(ldl.buildSetPrinterAlignmentPacket(k_bidi, 0, 0, 0))
  676.  
  677.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  678.         cmy_bidi = (6 - b) * 2
  679.         dev.printData(ldl.buildSetPrinterAlignmentPacket(0, 0, 0, cmy_bidi))
  680.  
  681.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  682.         vert = (9 - b) * 2
  683.         hort = (9 - c) * -2
  684.         k_bidi = (6 - d) * 2
  685.         cmy_bidi = (6 - e) * 2
  686.  
  687.         dev.printData(ldl.buildSetPrinterAlignmentPacket(k_bidi, hort, vert, cmy_bidi))
  688.  
  689.     # Set alignment
  690.     dev.printData(ldl.buildSetPensAlignedPacket())
  691.     dev.closePrint()
  692.  
  693.  
  694. def alignType4Phase3(dev): # Type 4 (LIDIL 0.3.8)
  695.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  696.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', 'cb2pcal_done.ldl.gz'))
  697.  
  698.  
  699. def alignType5Phase1(dev): # Type 5 (xBow+/LIDIL 0.4.3)
  700.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_RESUME_NORMAL_OPERATION))
  701.  
  702.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  703.         return
  704.  
  705.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  706.         ldl_file = 'cbbcal.ldl.gz'
  707.  
  708.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  709.         ldl_file = 'cbpcal.ldl.gz'
  710.  
  711.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  712.         ldl_file = 'cbccal.ldl.gz'
  713.  
  714.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  715.         ldl_file = 'cb2pcal.ldl.gz'
  716.  
  717.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  718.         ldl_file = 'cbcpcal.ldl.gz'
  719.  
  720.     dev.printData(ldl.buildZCAPacket(0))
  721.     dev.printData(ldl.buildColorHortPacket(0))
  722.     dev.printData(ldl.buildColorVertPacket(0))
  723.     dev.printData(ldl.buildBlackVertPacket(0))
  724.     dev.printData(ldl.buildBlackHortPacket(0))
  725.     dev.printData(ldl.buildBlackBidiPacket(0))
  726.     dev.printData(ldl.buildColorBidiPacket(0))
  727.     dev.printData(ldl.buildPhotoHuePacket(0))
  728.     dev.printData(ldl.buildColorHuePacket(0))
  729.     dev.closePrint()
  730.  
  731.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', ldl_file))
  732.  
  733.  
  734. def alignType5Phase2(dev, a, b, c, d, e, f, g): # Type 5 (xBow+/LIDIL 0.4.3)
  735.     log.debug("A=%d, B=%d, C=%d, D=%d, E=%d, F=%d, G=%d" % (a, b, c, d, e, f, g))
  736.  
  737.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  738.         return
  739.  
  740.     # ZCA
  741.     zca = (7 - a) * -48
  742.     dev.printData(ldl.buildZCAPacket(zca))
  743.  
  744.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  745.         k_bidi = (6 - b) * 2
  746.         dev.printData(ldl.buildBlackBidiPacket(k_bidi))
  747.  
  748.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  749.         kcm_bidi = (6 - b) * 2
  750.         dev.printData(ldl.buildPhotoBidiPacket(kcm_bidi))
  751.  
  752.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  753.         cmy_bidi = (6 - b) * 2
  754.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  755.  
  756.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  757.         vert = (9 - b) * 2
  758.         hort = (9 - c) * -2
  759.         k_bidi = (6 - d) * 2
  760.         cmy_bidi = (6 - e) * 2
  761.  
  762.         dev.printData(ldl.buildColorHortPacket(0))
  763.         dev.printData(ldl.buildColorVertPacket(0))
  764.         dev.printData(ldl.buildBlackVertPacket(vert))
  765.         dev.printData(ldl.buildBlackHortPacket(hort))
  766.         dev.printData(ldl.buildBlackBidiPacket(k_bidi))
  767.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  768.  
  769.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  770.         vert = (9 - b) * 2
  771.         hort = (9 - c) * -2
  772.         cmy_bidi = (6 - d) * 2
  773.         kcm_bidi = (6 - e) * 2
  774.  
  775.         photo_adj = colorcal.PHOTO_ALIGN_TABLE[f][g]
  776.         color_adj = colorcal.COLOR_ALIGN_TABLE[f][g]
  777.  
  778.         dev.printData(ldl.buildPhotoHortPacket(hort))
  779.         dev.printData(ldl.buildPhotoVertPacket(vert))
  780.         dev.printData(ldl.buildColorHortPacket(0))
  781.         dev.printData(ldl.buildColorVertPacket(0))
  782.         dev.printData(ldl.buildPhotoBidiPacket(kcm_bidi))
  783.         dev.printData(ldl.buildColorBidiPacket(cmy_bidi))
  784.         dev.printData(ldl.buildPhotoHuePacket(photo_adj))
  785.         dev.printData(ldl.buildColorHuePacket(color_adj))
  786.  
  787.     # Set alignment
  788.     dev.printData(ldl.buildSetPensAlignedPacket())
  789.     dev.closePrint()
  790.  
  791.  
  792. def alignType5Phase3(dev): # Type 5 (xBow+/LIDIL 0.4.3)
  793.     dev.closePrint()
  794.     if dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  795.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', "cb2pcal_done.ldl.gz"))
  796.  
  797.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  798.         dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'ldl', "cbccal_done.ldl.gz"))
  799.  
  800.  
  801. def alignType6Phase1(dev): # Type 6 (xBow AiO)
  802.     dev.printData(ldl.buildPrintInternalPagePacket())
  803.     dev.closePrint()
  804.  
  805. def alignType7Phase1(dev): # Type 7 (xBow VIP)
  806.     # Zero out all alignment values
  807.     dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, 0)
  808.  
  809.     dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, 0)
  810.     dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, 0)
  811.     dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, 0)
  812.  
  813.     dev.writeEmbeddedPML(pml.OID_AGENT3_VERTICAL_ALIGNMENT, 0)
  814.     dev.writeEmbeddedPML(pml.OID_AGENT3_HORIZONTAL_ALIGNMENT, 0)
  815.     dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, 0)
  816.  
  817.     dev.writeEmbeddedPML(pml.OID_ZCA, 0)
  818.  
  819.     if dev.pen_config in (AGENT_CONFIG_NONE, AGENT_CONFIG_INVALID):
  820.         return
  821.  
  822.     elif dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  823.         pcl_file = 'crbcal.pcl.gz'
  824.  
  825.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  826.         pcl_file = 'crpcal.pcl.gz'
  827.  
  828.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  829.         pcl_file = 'crccal.pcl.gz'
  830.  
  831.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  832.         pcl_file = 'crcbcal.pcl.gz'
  833.  
  834.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  835.         pcl_file = 'crcpcal.pcl.gz'
  836.  
  837.     dev.closePrint()
  838.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', pcl_file))
  839.  
  840.  
  841. def alignType7Phase2(dev, a, b, c, d, e, f, g): # Type 7 (xBow VIP)
  842.     log.debug("A=%d, B=%d, C=%d, D=%d, E=%d, F=%d, G=%d" % (a, b, c, d, e, f, g))
  843.  
  844.     # ZCA
  845.     zca = (7 - a) * -12
  846.     dev.writeEmbeddedPML(pml.OID_ZCA, zca)
  847.  
  848.     if dev.pen_config == AGENT_CONFIG_BLACK_ONLY:
  849.         k_bidi = (6 - b) * 6
  850.         dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, k_bidi)
  851.  
  852.     elif dev.pen_config == AGENT_CONFIG_PHOTO_ONLY:
  853.         kcm_bidi = (6 - b) * 6
  854.         dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, kcm_bidi)
  855.  
  856.     elif dev.pen_config == AGENT_CONFIG_COLOR_ONLY:
  857.         cmy_bidi = (6 - b) * 6
  858.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  859.  
  860.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_BLACK:
  861.         vert = (9 - b) * 6
  862.         hort = (9 - c) * -6
  863.         k_bidi = (6 - d) * 6
  864.         cmy_bidi = (6 - e) * 6
  865.  
  866.         dev.writeEmbeddedPML(pml.OID_AGENT1_BIDIR_ADJUSTMENT, k_bidi)
  867.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  868.         dev.writeEmbeddedPML(pml.OID_AGENT2_HORIZONTAL_ALIGNMENT, hort)
  869.         dev.writeEmbeddedPML(pml.OID_AGENT2_VERTICAL_ALIGNMENT, vert)
  870.  
  871.     elif dev.pen_config == AGENT_CONFIG_COLOR_AND_PHOTO:
  872.         vert = (9 - b) * 6
  873.         hort = (9 - c) * -6
  874.         cmy_bidi = (6 - d) * 6
  875.         kcm_bidi = (6 - e) * 6
  876.  
  877.         photo_adj = colorcal.PHOTO_ALIGN_TABLE[f][g]
  878.         color_adj = colorcal.COLOR_ALIGN_TABLE[f][g]
  879.  
  880.         x = (color_adj << 8) + photo_adj
  881.  
  882.         dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_SELECTION, x)
  883.  
  884.         dev.writeEmbeddedPML(pml.OID_AGENT2_BIDIR_ADJUSTMENT, cmy_bidi)
  885.         dev.writeEmbeddedPML(pml.OID_AGENT3_BIDIR_ADJUSTMENT, kcm_bidi)
  886.         dev.writeEmbeddedPML(pml.OID_AGENT3_HORIZONTAL_ALIGNMENT, hort)
  887.         dev.writeEmbeddedPML(pml.OID_AGENT3_VERTICAL_ALIGNMENT, vert)
  888.  
  889.     dev.closePrint()
  890.  
  891. def alignType7Phase3(dev): # Type 7 (xBow VIP)
  892.     dev.closePrint()
  893.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', "crcaldone.pcl.gz"))
  894.  
  895.  
  896. def alignType8Phase1(dev): # 450
  897.     pens = dev.getStatusFromDeviceID()['agents']
  898.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  899.  
  900.     if AGENT_TYPE_KCM in pen_types:
  901.         f, num_inks = 'align6_450.pcl.gz', 6
  902.     else:
  903.         f, num_inks = 'align4_450.pcl.gz', 4
  904.  
  905.     dev.closePrint()
  906.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', f))
  907.  
  908.     return num_inks
  909.  
  910.  
  911. def alignType8Phase2(dev, num_inks, a, b, c, d): # 450
  912.     align_values1 = {1 : '\x00\x00\x18',
  913.                       2 : '\x00\x00\x12',
  914.                       3 : '\x00\x00\x0c',
  915.                       4 : '\x00\x00\x06',
  916.                       5 : '\x00\x00\x00',
  917.                       6 : '\x01\x00\x06',
  918.                       7 : '\x01\x00\x0c',
  919.                       8 : '\x01\x00\x12',
  920.                       9 : '\x01\x00\x18',
  921.                     }
  922.  
  923.     align_values2 = {1 : '\x00\x00\x12',
  924.                       2 : '\x00\x00\x0c',
  925.                       3 : '\x00\x00\x06',
  926.                       4 : '\x00\x00\x00',
  927.                       5 : '\x01\x00\x06',
  928.                       6 : '\x01\x00\x0c',
  929.                       7 : '\x01\x00\x12',
  930.                       8 : '\x01\x00\x18',
  931.                       9 : '\x01\x00\x1e',
  932.                     }
  933.  
  934.     align_values3 = {1 : '\x00\x00\x24',
  935.                       2 : '\x00\x00\x18',
  936.                       3 : '\x00\x00\x12',
  937.                       4 : '\x00\x00\x06',
  938.                       5 : '\x00\x00\x00',
  939.                       6 : '\x01\x00\x06',
  940.                       7 : '\x01\x00\x12',
  941.                       8 : '\x01\x00\x18',
  942.                       9 : '\x01\x00\x24',
  943.                     }
  944.  
  945.     if num_inks == 4:
  946.         s = ''.join([pcl.UEL,
  947.               '@PJL ENTER LANGUAGE=PCL3GUI\n',
  948.               pcl.RESET,
  949.               pcl.ESC, '*o5W\x1a\x01', align_values1[a],
  950.               pcl.ESC, '*o5W\x1a\x02', align_values2[a],
  951.               pcl.ESC, '*o5W\x1a\x03', align_values1[b],
  952.               pcl.ESC, '*o5W\x1a\x04', align_values1[b],
  953.               pcl.ESC, '*o5W\x1a\x08', align_values1[c],
  954.               pcl.ESC, '*o5W\x1a\x07', align_values1[d],
  955.               pcl.RESET,
  956.               pcl.UEL])
  957.  
  958.     else: # 6
  959.         s = ''.join([pcl.UEL,
  960.               '@PJL ENTER LANGUAGE=PCL3GUI\n',
  961.               pcl.RESET,
  962.               pcl.ESC, '*o5W\x1a\x05', align_values1[a],
  963.               pcl.ESC, '*o5W\x1a\x06', align_values3[a],
  964.               pcl.ESC, '*o5W\x1a\x03', align_values1[b],
  965.               pcl.ESC, '*o5W\x1a\x04', align_values1[b],
  966.               pcl.ESC, '*o5W\x1a\x0a', align_values1[c],
  967.               pcl.ESC, '*o5W\x1a\x09', align_values1[d],
  968.               pcl.RESET,
  969.               pcl.UEL])
  970.  
  971.     dev.printData(s)
  972.     dev.closePrint()
  973.     
  974.     
  975. def AlignType12(dev, loadpaper_ui):
  976.     if loadpaper_ui():
  977.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_ALIGNMENT_PAGE)
  978.         dev.closePML()
  979.  
  980. # ********************** Clean **********************
  981.  
  982.  
  983. def cleaning(dev, clean_type, level1, level2, level3,
  984.               loadpaper_ui, dlg1, dlg2, dlg3, wait_ui):
  985.  
  986.     state = 0
  987.  
  988.     while state != -1:
  989.         if state == 0: # Initial level1 print
  990.             state = 1
  991.             if clean_type == CLEAN_TYPE_PCL_WITH_PRINTOUT:
  992.                 ok = loadpaper_ui()
  993.                 if not ok:
  994.                     state = -1
  995.  
  996.         elif state == 1: # Do level 1
  997.             level1(dev)
  998.             state = 2
  999.  
  1000.         elif state == 2: # Load plain paper
  1001.             state = -1
  1002.             ok = loadpaper_ui()
  1003.             if ok:
  1004.                 state = 3
  1005.  
  1006.         elif state == 3: # Print test page
  1007.             state = 4
  1008.             print_clean_test_page(dev)
  1009.  
  1010.         elif state == 4: # Need level 2?
  1011.             state = -1
  1012.             ok = dlg1()
  1013.             if ok:
  1014.                 state = 5
  1015.  
  1016.         elif state == 5: # Do level 2
  1017.             level2(dev)
  1018.             state = 6
  1019.  
  1020.         elif state == 6: # Load plain paper
  1021.             state = -1
  1022.             ok = loadpaper_ui()
  1023.             if ok:
  1024.                 state = 7
  1025.  
  1026.         elif state == 7: # Print test page
  1027.             state = 8
  1028.             print_clean_test_page(dev)
  1029.  
  1030.         elif state == 8: # Need level 3?
  1031.             state = -1
  1032.             ok = dlg2()
  1033.             if ok:
  1034.                 state = 9
  1035.  
  1036.         elif state == 9: # Do level 3
  1037.             level3(dev)
  1038.             state = 10
  1039.  
  1040.         elif state == 10: # Load plain paper
  1041.             state = -1
  1042.             ok = loadpaper_ui()
  1043.             if ok:
  1044.                 state = 11
  1045.  
  1046.         elif state == 11: # Print test page
  1047.             state = 12
  1048.             print_clean_test_page(dev)
  1049.  
  1050.         elif state == 12:
  1051.             state = -1
  1052.             dlg3()
  1053.  
  1054.     return ok
  1055.  
  1056.  
  1057. def print_clean_test_page(dev):
  1058.     dev.closePrint()
  1059.     dev.printGzipFile(os.path.join(prop.home_dir, 'data',
  1060.                       'ps', 'clean_page.pdf.gz'), raw=False)
  1061.  
  1062. def cleanType1(dev): # PCL, Level 1
  1063.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_CLEAN)
  1064.     dev.closePrint()
  1065.  
  1066. def primeType1(dev): # PCL, Level 2
  1067.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_PRIME)
  1068.     dev.closePrint()
  1069.  
  1070. def wipeAndSpitType1(dev): # PCL, Level 3
  1071.     dev.writeEmbeddedPML(pml.OID_CLEAN, pml.CLEAN_WIPE_AND_SPIT)
  1072.     dev.closePrint()
  1073.  
  1074. def cleanType2(dev): # LIDIL, Level 1
  1075.     dev.printData(ldl.buildResetPacket())
  1076.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND,
  1077.                                        ldl.COMMAND_HANDLE_PEN,
  1078.                                        ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL1))
  1079.     dev.closePrint()
  1080.  
  1081. def primeType2(dev): # LIDIL, Level 2
  1082.     dev.printData(ldl.buildResetPacket())
  1083.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND,
  1084.                                        ldl.COMMAND_HANDLE_PEN,
  1085.                                        ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL2))
  1086.     dev.closePrint()
  1087.  
  1088. def wipeAndSpitType2(dev): # LIDIL, Level 3
  1089.     dev.printData(ldl.buildResetPacket())
  1090.     dev.printData(ldl.buildLIDILPacket(ldl.PACKET_TYPE_COMMAND,
  1091.                                        ldl.COMMAND_HANDLE_PEN,
  1092.                                        ldl.COMMAND_HANDLE_PEN_CLEAN_LEVEL3))
  1093.     dev.closePrint()
  1094.  
  1095.  
  1096. # ********************** Color Cal **********************
  1097.  
  1098.  
  1099. def colorCalType1(dev, loadpaper_ui, colorcal_ui, photopenreq_ui): # 450
  1100.     value, state = 4, 0
  1101.     ok = False
  1102.     while state != -1:
  1103.  
  1104.         if state == 0:
  1105.             if colorCalType1PenCheck(dev):
  1106.                 state = 1
  1107.             else:
  1108.                 state = 100
  1109.  
  1110.         elif state == 1:
  1111.             state = -1
  1112.             ok = loadpaper_ui()
  1113.             if ok:
  1114.                 colorCalType1Phase1(dev)
  1115.                 state = 2
  1116.  
  1117.         elif state == 2:
  1118.             state = -1
  1119.             ok, value = colorcal_ui()
  1120.             if ok:
  1121.                 state = 3
  1122.  
  1123.         elif state == 3:
  1124.             colorCalType1Phase2(dev, value)
  1125.             state = -1
  1126.  
  1127.         elif state == 100:
  1128.             ok = False
  1129.             photopenreq_ui()
  1130.             state = -1
  1131.  
  1132.     return ok
  1133.  
  1134.  
  1135. def colorCalType1PenCheck(dev): # 450
  1136.     pens = dev.getStatusFromDeviceID()['agents']
  1137.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  1138.  
  1139.     if AGENT_TYPE_KCM in pen_types:
  1140.         return True
  1141.  
  1142.     else:
  1143.         log.error("Cannot perform color calibration with no photo pen installed.")
  1144.         return False
  1145.  
  1146.  
  1147. def colorCalType1Phase1(dev): # 450
  1148.     dev.closePrint()
  1149.     dev.printGzipFile(os.path.join(prop.home_dir, 'data', 'pcl', 'colorcal1_450.pcl.gz'))
  1150.  
  1151.  
  1152. def colorCalType1Phase2(dev, value): # 450
  1153.     color_cal = {1 : ('\x0f\x3c', '\x17\x0c'),
  1154.                   2 : ('\x10\xcc', '\x15\x7c'),
  1155.                   3 : ('\x12\x5c', '\x13\xec'),
  1156.                   4 : ('\x13\xec', '\x12\x5c'),
  1157.                   5 : ('\x15\x7c', '\x10\xcc'),
  1158.                   6 : ('\x17\x0c', '\x0f\x3c'),
  1159.                   7 : ('\x18\x9c', '\x0d\xac'),
  1160.                 }
  1161.  
  1162.     s = ''.join([pcl.UEL,
  1163.                   '@PJL ENTER LANGUAGE=PCL3GUI\n',
  1164.                   pcl.RESET,
  1165.                   pcl.ESC, '*o5W\x1a\x0c\x00', color_cal[value][0],
  1166.                   pcl.ESC, '*o5W\x1a\x0b\x00', color_cal[value][1],
  1167.                   pcl.RESET,
  1168.                   pcl.UEL])
  1169.  
  1170.     dev.printData(s)
  1171.     dev.closePrint()
  1172.  
  1173. #
  1174. # COLOR CAL TYPE 2
  1175. #
  1176.  
  1177. def colorCalType2(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  1178.     value, state = 4, 0
  1179.     ok = True
  1180.     while state != -1:
  1181.  
  1182.         if state == 0:
  1183.             if colorCalType2PenCheck(dev):
  1184.                 state = 1
  1185.             else:
  1186.                 state = 100
  1187.  
  1188.         elif state == 1:
  1189.             state = -1
  1190.             ok = loadpaper_ui()
  1191.             if ok:
  1192.                 colorCalType2Phase1(dev)
  1193.                 state = 2
  1194.  
  1195.         elif state == 2:
  1196.             state = -1
  1197.             ok, value = colorcal_ui()
  1198.             if ok:
  1199.                 state = 3
  1200.  
  1201.         elif state == 3:
  1202.             colorCalType2Phase2(dev, value)
  1203.             state = -1
  1204.  
  1205.         elif state == 100:
  1206.             photopenreq_ui()
  1207.             ok = False
  1208.             state = -1
  1209.  
  1210.     return ok
  1211.  
  1212. def colorCalType2PenCheck(dev):
  1213.     pens = dev.getStatusFromDeviceID()['agents']
  1214.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  1215.  
  1216.     if not AGENT_TYPE_NONE in pen_types:
  1217.         return True
  1218.  
  1219.     else:
  1220.         log.error("Cannot perform color calibration with pens missing.")
  1221.         return False
  1222.  
  1223. def colorCalType2Phase1(dev):
  1224.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  1225.                          pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1226.  
  1227.     dev.closePrint()
  1228.  
  1229.  
  1230. def colorCalType2Phase2(dev, value):
  1231.     c = colorcal.COLOR_CAL_TABLE
  1232.     p = ''.join(['\x1b&b19WPML \x04\x00\x06\x01\x04\x01\x05\x01\t\x08\x04',
  1233.                    chr(c[value*4]+100), chr(c[value*4+1]+100),
  1234.                    chr(c[value*4+2]+100), chr(c[value*4+3]+100),
  1235.                    '\x1b%-12345X'])
  1236.  
  1237.     dev.printData(p)
  1238.     dev.closePrint()
  1239.  
  1240.  
  1241. #
  1242. # COLOR CAL TYPE 3
  1243. #
  1244.  
  1245. def colorCalType3(dev, loadpaper_ui, colorcal_ui, photopenreq_ui):
  1246.     value, state = 4, 0
  1247.     ok = True
  1248.     while state != -1:
  1249.  
  1250.         if state == 0:
  1251.             if colorCalType3PenCheck(dev):
  1252.                 state = 1
  1253.             else:
  1254.                 state = 100
  1255.  
  1256.         elif state == 1:
  1257.             state = -1
  1258.             ok = loadpaper_ui()
  1259.             if ok:
  1260.                 colorCalType3Phase1(dev)
  1261.                 state = 2
  1262.  
  1263.         elif state == 2:
  1264.             state = -1
  1265.             ok, valueA = colorcal_ui('A', 21)
  1266.             if ok:
  1267.                 state = 3
  1268.  
  1269.         elif state == 3:
  1270.             state = -1
  1271.             ok, valueB = colorcal_ui('B', 21)
  1272.             if ok:
  1273.                 state = 4
  1274.  
  1275.         elif state == 4:
  1276.             colorCalType3Phase2(dev, valueA, valueB)
  1277.             state = -1
  1278.  
  1279.         elif state == 100:
  1280.             photopenreq_ui()
  1281.             ok = False
  1282.             state = -1
  1283.  
  1284.     return ok
  1285.  
  1286. def colorCalType3PenCheck(dev):
  1287.     pens = dev.getStatusFromDeviceID()['agents']
  1288.     pen_types = [pens[x]['type'] for x in range(len(pens))]
  1289.  
  1290.     if AGENT_TYPE_KCM in pen_types or \
  1291.       AGENT_TYPE_BLUE in pen_types:
  1292.         return True
  1293.  
  1294.     else:
  1295.         log.error("Cannot perform color calibration with no photo (or photo blue) pen installed.")
  1296.         return False
  1297.  
  1298.  
  1299. def colorCalType3Phase1(dev):
  1300.     dev.writeEmbeddedPML(pml.OID_PRINT_INTERNAL_PAGE,
  1301.                          pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1302.     dev.closePrint()
  1303.  
  1304. def colorCalType3Phase2(dev, A, B):
  1305.     photo_adj = colorcal.PHOTO_ALIGN_TABLE[A-1][B-1]
  1306.     color_adj = colorcal.COLOR_ALIGN_TABLE[A-1][B-1]
  1307.     adj_value = (color_adj << 8L) + photo_adj
  1308.  
  1309.     dev.writeEmbeddedPML(pml.OID_COLOR_CALIBRATION_SELECTION, adj_value)
  1310.     dev.closePrint()
  1311.  
  1312. def colorCalType4(dev, loadpaper_ui, colorcal_ui, wait_ui):
  1313.     state = 0
  1314.     ok = True
  1315.  
  1316.     while state != -1:
  1317.         if state == 0:
  1318.             state = -1
  1319.             ok = loadpaper_ui()
  1320.             if ok:
  1321.                 colorCalType4Phase1(dev)
  1322.                 state = 2
  1323.  
  1324.         elif state == 2:
  1325.             state = -1
  1326.             #wait_ui(90)
  1327.             ok, values = colorcal_ui()
  1328.             if ok:
  1329.                 state = 3
  1330.  
  1331.         elif state == 3:
  1332.             colorCalType4Phase2(dev, values)
  1333.             #wait_ui(5)
  1334.             state = 4
  1335.  
  1336.         elif state == 4:
  1337.             state = -1
  1338.             ok = loadpaper_ui()
  1339.             if ok:
  1340.                 colorCalType4Phase3(dev)
  1341.                 state = -1
  1342.  
  1343.     return ok
  1344.  
  1345.  
  1346. def colorCalType4Phase1(dev):
  1347.     dev.setPML(pml.OID_PRINT_INTERNAL_PAGE,
  1348.               pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1349.               
  1350.     dev.closePML()
  1351.  
  1352.  
  1353. def colorCalType4AdjValue(value):
  1354.     if value >= 100:
  1355.         return 200
  1356.     return value+100
  1357.  
  1358.  
  1359. def colorCalType4Phase2(dev, values):
  1360.     if -1 in values:
  1361.         Cadj, Madj, Yadj, cadj, madj, kadj = 244, 244, 244, 244, 244, 244
  1362.     else:
  1363.         sel1, sel2, sel3, sel4 = values
  1364.         tmp1 = colorcal.TYPE_4_C_TABLE[sel1][sel2]
  1365.         tmp2 = colorcal.TYPE_4_LC_TABLE[sel3][sel4]
  1366.  
  1367.         Cadj = colorCalType4AdjValue(tmp1)
  1368.         cadj = colorCalType4AdjValue(tmp1+tmp2)
  1369.  
  1370.         tmp1 = colorcal.TYPE_4_M_TABLE[sel1][sel2]
  1371.         tmp2 = colorcal.TYPE_4_LM_TABLE[sel3][sel4]
  1372.  
  1373.         Madj = colorCalType4AdjValue(tmp1)
  1374.         madj = colorCalType4AdjValue(tmp1+tmp2)
  1375.  
  1376.         Yadj = colorCalType4AdjValue(colorcal.TYPE_4_Y_TABLE[sel1][sel2])
  1377.         kadj = colorCalType4AdjValue(0)
  1378.  
  1379.     log.debug("C=%d, M=%d, Y=%d, c=%d, m=%d, k=%d\n" % (Cadj, Madj, Yadj, cadj, madj, kadj))
  1380.  
  1381.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_1,
  1382.                             kadj)
  1383.                             
  1384.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_2,
  1385.                             Cadj)
  1386.                             
  1387.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_3,
  1388.                             Madj)
  1389.     
  1390.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_4,
  1391.                             Yadj)
  1392.                             
  1393.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_5,
  1394.                             cadj)
  1395.     
  1396.     dev.setPML(pml.OID_COLOR_CALIBRATION_ARRAY_6,
  1397.                             madj)
  1398.                             
  1399.     dev.closePML()
  1400.  
  1401.  
  1402. def colorCalType4Phase3(dev):
  1403.     dev.setPML(pml.OID_PRINT_INTERNAL_PAGE,
  1404.                          pml.PRINT_INTERNAL_PAGE_COLOR_PALETTE_CMYK_PAGE)
  1405.                          
  1406.     dev.closePML()
  1407.  
  1408.  
  1409. def colorCalType5(dev, loadpaper_ui):
  1410.     if loadpaper_ui():
  1411.         dev.printData("""\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 20;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X""")
  1412.         dev.closePrint()
  1413.  
  1414.         
  1415. def colorCalType6(dev, loadpaper_ui):
  1416.     if loadpaper_ui():
  1417.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_COLOR_CAL)
  1418.         dev.closePML()
  1419.         
  1420. def colorCalType7(dev, loadpaper_ui):
  1421.     if loadpaper_ui():
  1422.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_AUTOMATIC_COLOR_CALIBRATION)
  1423.         dev.closePML()
  1424.  
  1425. # ********************** LF Cal **********************        
  1426.         
  1427. def linefeedCalType1(dev, loadpaper_ui):
  1428.     if loadpaper_ui():
  1429.         dev.printData("""\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 3;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X""")
  1430.         dev.closePrint()
  1431.         
  1432. def linefeedCalType2(dev, loadpaper_ui):
  1433.     if loadpaper_ui():
  1434.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_LINEFEED_CALIBRATION)
  1435.         dev.closePML()
  1436.  
  1437.  
  1438. # ********************** PQ Diag **********************        
  1439.         
  1440. def printQualityDiagType1(dev, loadpaper_ui):
  1441.     if loadpaper_ui():
  1442.         dev.printData("""\x1b%-12345X@PJL ENTER LANGUAGE=PCL3GUI\n\x1bE\x1b%Puifp.multi_button_push 14;\nudw.quit;\x1b*rC\x1bE\x1b%-12345X""")
  1443.         dev.closePrint()
  1444.  
  1445. def printQualityDiagType2(dev, loadpaper_ui):
  1446.     if loadpaper_ui():
  1447.         dev.setPML(pml.OID_PRINT_INTERNAL_PAGE, pml.PRINT_INTERNAL_PAGE_PRINT_QUALITY_DIAGNOSTIC)
  1448.         dev.closePML()
  1449.